#include <iostream>
#include <type_traits>
#include <string>

namespace cpp23 {

// 传统的CRTP（奇异递归模板模式）实现
template <typename Derived>
class base_crtp {
public:
  void interface() {
    // 转换为派生类指针并调用方法
    static_cast<Derived*>(this)->implementation();
  }

  // 默认实现
  void implementation() {
    std::cout << "基类的默认实现\n";
  }
};

class derived_crtp : public base_crtp<derived_crtp> {
public:
  void implementation() {
    std::cout << "派生类的实现\n";
  }
};

// 使用C++23 deducing this的等价类
class base_deducing_this {
public:
  // 使用explicit object parameter (显式对象参数)
  // 注意：GCC 13可能不完全支持此特性，使用替代实现
  template <typename Self>
  void interface_impl(Self&& self) {
    std::forward<Self>(self).implementation();
  }
  
  // 非模板版本用于演示
  void interface() {
    implementation();
  }

  void implementation() {
    std::cout << "基类的默认实现\n";
  }
};

class derived_deducing_this : public base_deducing_this {
public:
  void implementation() {
    std::cout << "派生类的实现\n";
  }
};

// 展示不同引用限定符的例子
class my_string {
private:
  std::string m_data;

public:
  my_string(const char* s) : m_data(s) {}

  // 注意：GCC 13不支持显式对象参数，使用传统重载方式
  const std::string& data() const& {
    std::cout << "const&版本被调用\n";
    return m_data;
  }
  
  std::string& data() & {
    std::cout << "非const&版本被调用\n";
    return m_data;
  }
  
  std::string&& data() && {
    std::cout << "&&版本被调用\n";
    return std::move(m_data);
  }
};

// 递归链式调用示例
// 注意：GCC 13不支持显式对象参数，使用传统方式
class chainable {
public:
  chainable& set_value(int val) {
    std::cout << "设置值: " << val << "\n";
    return *this;
  }
  
  chainable& log(const std::string& message) {
    std::cout << "日志: " << message << "\n";
    return *this;
  }
};

} // namespace cpp23

void demonstrate_deducing_this() {
  using namespace cpp23;

  std::cout << "C++23 deducing this 特性演示\n";
  std::cout << "============================\n\n";

  // 1. CRTP与deducing this比较
  std::cout << "1. CRTP与deducing this比较:\n";
  std::cout << "CRTP版本:\n";
  derived_crtp d_crtp;
  d_crtp.interface();  // 通过CRTP调用派生类实现

  std::cout << "\ndeducing this版本:\n";
  derived_deducing_this d_deducing;
  d_deducing.interface();  // 通过deducing this调用派生类实现

  // 2. 引用限定符多态性
  std::cout << "\n2. 引用限定符多态性:\n";
  my_string s("Hello");
  const my_string& cs = s;

  s.data();    // 非const版本
  cs.data();   // const版本
  
  // 3. 链式调用
  std::cout << "\n3. 链式调用示例:\n";
  chainable chain;
  chain.set_value(42)
       .log("值已设置")
       .set_value(100)
       .log("值已更新");

  std::cout << "\nC++23 deducing this的优势:\n";
  std::cout << "1. 简化CRTP模式，不需要额外的模板参数\n";
  std::cout << "2. 减少引用限定符重载的代码冗余\n";
  std::cout << "3. 使链式调用更加简洁高效\n";
  std::cout << "4. 可以统一处理各种引用限定符情况\n";
  std::cout << "5. 提高代码可读性和维护性\n";
} 